/*
 * Copyright (c) 2008-2017 浩瀚深度 All Rights Reserved.
 *
 * FileName: JsonMsgHelper.java
 *
 * Description：
 *
 * History:
 * v1.0.0, zmw, 2017年8月9日, Create
 */
package com.monitor.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.parser.deserializer.ParseProcess;
import com.alibaba.fastjson.serializer.PropertyFilter;
import com.alibaba.fastjson.serializer.SerializeFilter;

/**
 * @author zmw
 * @version 1.0.0
 * @since 1.0.0
 */
public class JsonMsgHelper {
    /**
     *
     */
    private JsonMsgHelper() {
        //do nothing
    }

    /**
     * 将JSON转换为字符串格式
     *
     * @param jsonMsgRequest json请求消息
     * @return string
     */
    public static String convertJsonMsgRequest2Cmd(JsonMsgRequest jsonMsgRequest) {
        return convertJsonMsgRequest2Cmd(jsonMsgRequest, null);
    }

    /**
     * 按照指定的配置，将JSON转换为字符串格式
     *
     * @param jsonMsgRequest json请求消息
     * @param filter         指定的解析配置
     * @return String
     */
    public static String convertJsonMsgRequest2Cmd(JsonMsgRequest jsonMsgRequest, SerializeFilter filter) {
        filter = filter == null ? obtainToMsgFilter() : filter;
        return JSON.toJSONString(jsonMsgRequest, filter);
    }

    /**
     * 将字符串的命令转换为对象
     *
     * @param cmd 字符串命令
     * @return Json对象
     */
    public static JsonMsgRequest convertCmd2JsonMsgRequest(String cmd) {
        return convertCmd2JsonMsgRequest(cmd, null);
    }

    /**
     * 按照指定的规则，将字符串的命令转换为对象
     *
     * @param cmd          字符串命令
     * @param parseProcess 指定的解析配置
     * @return 对象
     */
    public static JsonMsgRequest convertCmd2JsonMsgRequest(String cmd, ParseProcess parseProcess) {
        if (parseProcess == null) {
            return (JsonMsgRequest) JSON.parseObject(cmd, JsonMsgRequest.class);
        }
        return (JsonMsgRequest) JSON.parseObject(cmd, JsonMsgRequest.class, parseProcess);
    }

    /**
     * 将JSON应答对象转换为字符串命令
     *
     * @param <T>
     * @param msgResponse JSON应答对象
     * @return String
     */
    public static <T> String convertJsonMsgResponse2Cmd(JsonMsgResponse<T> msgResponse) {
        return convertJsonMsgResponse2Cmd(msgResponse, null);
    }

    /**
     * 按照指定的配置，将JSON应答对象转换为字符串命令
     *
     * @param <T>
     * @param msgResponse JSON应答对象
     * @param filter      指定解析配置
     * @return String
     */
    public static <T> String convertJsonMsgResponse2Cmd(JsonMsgResponse<T> msgResponse,
                                                        SerializeFilter filter) {
        filter = filter == null ? obtainToMsgFilter() : filter;
        return JSON.toJSONString(msgResponse, filter);
    }

    /**
     * 将字符串命令转换为JSON应答对象
     *
     * @param <T>
     * @param cmd  字符串命令
     * @param type
     * @return JSON应答对象
     */
    public static <T> T convertCmd2JsonMsgResponse(String cmd, TypeReference<T> type) {
        return convertCmd2JsonMsgResponse(cmd, type, null);
    }
    /**
     * 将字符串命令转换为JSON应答对象
     * @param cmd 字符串命令
     * @param classMap 子对象类型
     * @return JSON应答对象
     *//*
    public static JsonMsgResponse convertCmd2JsonMsgResponse(String cmd,
            Map<String, Class<?>> classMap)
    {
        return convertCmd2JsonMsgResponse(cmd, classMap, null);
    }
    *//**
     * 按照指定的解析配置，将字符串命令转换为JSON应答对象
     * @param cmd 字符串命令
     * @param classMap 子对象类型
     * @param jsonConfig 指定的解析配
     * @return JSON应答对象
     *//*
    public static JsonMsgResponse convertCmd2JsonMsgResponse(String cmd,
            Map<String, Class<?>> classMap, JsonConfig jsonConfig)
    {
        jsonConfig = jsonConfig == null ? obtainJsonConfig() : jsonConfig;
        JSONObject jsonObject = JSONObject.fromObject(cmd, obtainJsonConfig());
        return (JsonMsgResponse) JSONObject.toBean(jsonObject, JsonMsgResponse.class, classMap);
    }*/

    /**
     * 按照指定的解析配置，将字符串命令转换为JSON应答对象
     *
     * @param <T>
     * @param cmd          字符串命令
     * @param type         解析类型
     * @param parseProcess 指定的解析配置
     * @return JSON应答对象
     */
    public static <T> T convertCmd2JsonMsgResponse(String cmd, TypeReference<T> type,
                                                   ParseProcess parseProcess) {
        if (parseProcess != null) {

        }
        return (T) JSON.parseObject(cmd, type);
    }

    /**
     * 按照指定的解析配置，将字符串命令转换为JSON应答对象
     *
     * @param <T>
     * @param cmd          JSON串
     * @param clazz        转换类型
     * @param parseProcess 指定的解析配置
     * @return JSON应答对象
     */
    public static <T> T convertCmd2JsonMsgResponse(String cmd, Class<T> clazz, ParseProcess parseProcess) {
        return (T) JSON.parseObject(cmd, clazz, parseProcess);
    }

    /**
     * 全属性解析
     *
     * @return JsonConfig
     */
    private static SerializeFilter obtainToMsgFilter() {
        return new PropertyFilter() {

            @Override
            public boolean apply(Object object, String propertyName, Object propertyValue) {
                if (propertyValue != null) {
                    return true;
                }
                return false;
            }
        };
    }
}
